home *** CD-ROM | disk | FTP | other *** search
/ Micromanía: 150 Juegos 2010 / 150Juegos_16.iso / Shareware / Shape Smash / shape-smash.swf / scripts / Box2D / Dynamics / _th791.as < prev    next >
Encoding:
Text File  |  2010-05-14  |  19.7 KB  |  725 lines
  1. package Box2D.Dynamics
  2. {
  3.    import Box2D.Collision.Shapes._fh319;
  4.    import Box2D.Collision.Shapes._hx306;
  5.    import Box2D.Collision.Shapes._sw544;
  6.    import Box2D.Common.Math._bf172;
  7.    import Box2D.Common.Math._ni781;
  8.    import Box2D.Common.Math._oh327;
  9.    import Box2D.Common.Math._ui293;
  10.    import Box2D.Common.Math.b2Vec2;
  11.    import Box2D.Dynamics.Contacts._eg754;
  12.    import Box2D.Dynamics.Joints._gs664;
  13.    
  14.    public class _th791
  15.    {
  16.       private static var s_massData:_fh319 = new _fh319();
  17.       
  18.       private static var s_xf1:_ni781 = new _ni781();
  19.       
  20.       public static var e_frozenFlag:uint = 2;
  21.       
  22.       public static var e_islandFlag:uint = 4;
  23.       
  24.       public static var e_sleepFlag:uint = 8;
  25.       
  26.       public static var e_allowSleepFlag:uint = 16;
  27.       
  28.       public static var e_bulletFlag:uint = 32;
  29.       
  30.       public static var e_fixedRotationFlag:uint = 64;
  31.       
  32.       public static var e_staticType:uint = 1;
  33.       
  34.       public static var e_dynamicType:uint = 2;
  35.       
  36.       public static var e_maxTypes:uint = 3;
  37.       
  38.       public var m_next:_th791;
  39.       
  40.       public var m_contactList:_eg754;
  41.       
  42.       public var m_angularVelocity:Number;
  43.       
  44.       public var m_mass:Number;
  45.       
  46.       public var m_force:b2Vec2;
  47.       
  48.       public var m_sweep:_bf172;
  49.       
  50.       public var m_xf:_ni781;
  51.       
  52.       public var m_torque:Number;
  53.       
  54.       public var m_shapeList:_hx306;
  55.       
  56.       public var m_flags:uint;
  57.       
  58.       public var m_invI:Number;
  59.       
  60.       public var m_invMass:Number;
  61.       
  62.       public var m_linearVelocity:b2Vec2;
  63.       
  64.       public var m_prev:_th791;
  65.       
  66.       public var m_userData:*;
  67.       
  68.       public var m_linearDamping:Number;
  69.       
  70.       public var m_type:int;
  71.       
  72.       public var m_world:_fp437;
  73.       
  74.       public var m_angularDamping:Number;
  75.       
  76.       public var m_shapeCount:int;
  77.       
  78.       public var m_jointList:_gs664;
  79.       
  80.       public var m_I:Number;
  81.       
  82.       public var m_sleepTime:Number;
  83.       
  84.       public function _th791(param1:_qh446, param2:_fp437)
  85.       {
  86.          var _loc3_:_oh327 = null;
  87.          var _loc4_:b2Vec2 = null;
  88.          m_xf = new _ni781();
  89.          m_sweep = new _bf172();
  90.          m_linearVelocity = new b2Vec2();
  91.          m_force = new b2Vec2();
  92.          super();
  93.          m_flags = 0;
  94.          if(param1.isBullet)
  95.          {
  96.             m_flags |= e_bulletFlag;
  97.          }
  98.          if(param1.fixedRotation)
  99.          {
  100.             m_flags |= e_fixedRotationFlag;
  101.          }
  102.          if(param1.allowSleep)
  103.          {
  104.             m_flags |= e_allowSleepFlag;
  105.          }
  106.          if(param1.isSleeping)
  107.          {
  108.             m_flags |= e_sleepFlag;
  109.          }
  110.          m_world = param2;
  111.          m_xf.position._kh737(param1.position);
  112.          m_xf.R._br741(param1.angle);
  113.          m_sweep.localCenter._kh737(param1.massData.center);
  114.          m_sweep.t0 = 1;
  115.          m_sweep.a0 = m_sweep.a = param1.angle;
  116.          _loc3_ = m_xf.R;
  117.          _loc4_ = m_sweep.localCenter;
  118.          m_sweep.c.x = _loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y;
  119.          m_sweep.c.y = _loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y;
  120.          m_sweep.c.x += m_xf.position.x;
  121.          m_sweep.c.y += m_xf.position.y;
  122.          m_sweep.c0._kh737(m_sweep.c);
  123.          m_jointList = null;
  124.          m_contactList = null;
  125.          m_prev = null;
  126.          m_next = null;
  127.          m_linearDamping = param1.linearDamping;
  128.          m_angularDamping = param1.angularDamping;
  129.          m_force._br741(0,0);
  130.          m_torque = 0;
  131.          m_linearVelocity._he34();
  132.          m_angularVelocity = 0;
  133.          m_sleepTime = 0;
  134.          m_invMass = 0;
  135.          m_I = 0;
  136.          m_invI = 0;
  137.          m_mass = param1.massData.mass;
  138.          if(m_mass > 0)
  139.          {
  140.             m_invMass = 1 / m_mass;
  141.          }
  142.          if((m_flags & _th791.e_fixedRotationFlag) == 0)
  143.          {
  144.             m_I = param1.massData.I;
  145.          }
  146.          if(m_I > 0)
  147.          {
  148.             m_invI = 1 / m_I;
  149.          }
  150.          if(m_invMass == 0 && m_invI == 0)
  151.          {
  152.             m_type = e_staticType;
  153.          }
  154.          else
  155.          {
  156.             m_type = e_dynamicType;
  157.          }
  158.          m_userData = param1.userData;
  159.          m_shapeList = null;
  160.          m_shapeCount = 0;
  161.       }
  162.       
  163.       public function _sd781() : Number
  164.       {
  165.          return m_angularVelocity;
  166.       }
  167.       
  168.       public function _lx197(param1:b2Vec2) : b2Vec2
  169.       {
  170.          return _ui293._mx194(m_xf,param1);
  171.       }
  172.       
  173.       public function _jq282() : b2Vec2
  174.       {
  175.          return m_xf.position;
  176.       }
  177.       
  178.       public function _na399() : _fp437
  179.       {
  180.          return m_world;
  181.       }
  182.       
  183.       public function _ix313() : _th791
  184.       {
  185.          return m_next;
  186.       }
  187.       
  188.       public function _lq766() : _ni781
  189.       {
  190.          return m_xf;
  191.       }
  192.       
  193.       public function _sl392(param1:b2Vec2, param2:b2Vec2) : void
  194.       {
  195.          if(_bk718())
  196.          {
  197.             _uo631();
  198.          }
  199.          m_force.x += param1.x;
  200.          m_force.y += param1.y;
  201.          m_torque += (param2.x - m_sweep.c.x) * param1.y - (param2.y - m_sweep.c.y) * param1.x;
  202.       }
  203.       
  204.       public function _ti631(param1:Boolean) : void
  205.       {
  206.          if(param1)
  207.          {
  208.             m_flags |= e_allowSleepFlag;
  209.          }
  210.          else
  211.          {
  212.             m_flags &= ~e_allowSleepFlag;
  213.             _uo631();
  214.          }
  215.       }
  216.       
  217.       public function _fj733() : Number
  218.       {
  219.          return m_mass;
  220.       }
  221.       
  222.       public function _hg747(param1:b2Vec2) : b2Vec2
  223.       {
  224.          var _loc2_:_oh327 = null;
  225.          var _loc3_:b2Vec2 = null;
  226.          _loc2_ = m_xf.R;
  227.          _loc3_ = new b2Vec2(_loc2_.col1.x * param1.x + _loc2_.col2.x * param1.y,_loc2_.col1.y * param1.x + _loc2_.col2.y * param1.y);
  228.          _loc3_.x += m_xf.position.x;
  229.          _loc3_.y += m_xf.position.y;
  230.          return new b2Vec2(m_linearVelocity.x + m_angularVelocity * (_loc3_.y - m_sweep.c.y),m_linearVelocity.x - m_angularVelocity * (_loc3_.x - m_sweep.c.x));
  231.       }
  232.       
  233.       public function _sb691() : void
  234.       {
  235.          var _loc1_:_hx306 = null;
  236.          var _loc2_:Number = NaN;
  237.          var _loc3_:Number = NaN;
  238.          var _loc4_:_fh319 = null;
  239.          var _loc5_:_oh327 = null;
  240.          var _loc6_:b2Vec2 = null;
  241.          var _loc7_:int = 0;
  242.          if(m_world.m_lock == true)
  243.          {
  244.             return;
  245.          }
  246.          m_mass = 0;
  247.          m_invMass = 0;
  248.          m_I = 0;
  249.          m_invI = 0;
  250.          _loc2_ = 0;
  251.          _loc3_ = 0;
  252.          _loc4_ = s_massData;
  253.          _loc1_ = m_shapeList;
  254.          while(_loc1_)
  255.          {
  256.             _loc1_._se554(_loc4_);
  257.             m_mass += _loc4_.mass;
  258.             _loc2_ += _loc4_.mass * _loc4_.center.x;
  259.             _loc3_ += _loc4_.mass * _loc4_.center.y;
  260.             m_I += _loc4_.I;
  261.             _loc1_ = _loc1_.m_next;
  262.          }
  263.          if(m_mass > 0)
  264.          {
  265.             m_invMass = 1 / m_mass;
  266.             _loc2_ *= m_invMass;
  267.             _loc3_ *= m_invMass;
  268.          }
  269.          if(m_I > 0 && (m_flags & e_fixedRotationFlag) == 0)
  270.          {
  271.             m_I -= m_mass * (_loc2_ * _loc2_ + _loc3_ * _loc3_);
  272.             m_invI = 1 / m_I;
  273.          }
  274.          else
  275.          {
  276.             m_I = 0;
  277.             m_invI = 0;
  278.          }
  279.          m_sweep.localCenter._br741(_loc2_,_loc3_);
  280.          _loc5_ = m_xf.R;
  281.          _loc6_ = m_sweep.localCenter;
  282.          m_sweep.c.x = _loc5_.col1.x * _loc6_.x + _loc5_.col2.x * _loc6_.y;
  283.          m_sweep.c.y = _loc5_.col1.y * _loc6_.x + _loc5_.col2.y * _loc6_.y;
  284.          m_sweep.c.x += m_xf.position.x;
  285.          m_sweep.c.y += m_xf.position.y;
  286.          m_sweep.c0._kh737(m_sweep.c);
  287.          _loc1_ = m_shapeList;
  288.          while(_loc1_)
  289.          {
  290.             _loc1_._nw364(m_sweep.localCenter);
  291.             _loc1_ = _loc1_.m_next;
  292.          }
  293.          _loc7_ = m_type;
  294.          if(m_invMass == 0 && m_invI == 0)
  295.          {
  296.             m_type = e_staticType;
  297.          }
  298.          else
  299.          {
  300.             m_type = e_dynamicType;
  301.          }
  302.          if(_loc7_ != m_type)
  303.          {
  304.             _loc1_ = m_shapeList;
  305.             while(_loc1_)
  306.             {
  307.                _loc1_._jt704(m_world.m_broadPhase,m_xf);
  308.                _loc1_ = _loc1_.m_next;
  309.             }
  310.          }
  311.       }
  312.       
  313.       public function _kp162() : Number
  314.       {
  315.          return m_I;
  316.       }
  317.       
  318.       public function _yd753() : b2Vec2
  319.       {
  320.          return m_sweep.c;
  321.       }
  322.       
  323.       public function _dn786(param1:Number) : void
  324.       {
  325.          if(_bk718())
  326.          {
  327.             _uo631();
  328.          }
  329.          m_torque += param1;
  330.       }
  331.       
  332.       public function _vw196() : Boolean
  333.       {
  334.          return (m_flags & e_frozenFlag) == e_frozenFlag;
  335.       }
  336.       
  337.       public function _bk718() : Boolean
  338.       {
  339.          return (m_flags & e_sleepFlag) == e_sleepFlag;
  340.       }
  341.       
  342.       public function _ss678() : _gs664
  343.       {
  344.          return m_jointList;
  345.       }
  346.       
  347.       public function _rn741(param1:b2Vec2) : b2Vec2
  348.       {
  349.          return _ui293._xj516(m_xf.R,param1);
  350.       }
  351.       
  352.       public function _uo631() : void
  353.       {
  354.          m_flags &= ~e_sleepFlag;
  355.          m_sleepTime = 0;
  356.       }
  357.       
  358.       public function _nd202() : Boolean
  359.       {
  360.          return m_type == e_dynamicType;
  361.       }
  362.       
  363.       public function _me458(param1:Number) : void
  364.       {
  365.          m_angularVelocity = param1;
  366.       }
  367.       
  368.       public function _pg676() : b2Vec2
  369.       {
  370.          return m_sweep.localCenter;
  371.       }
  372.       
  373.       public function _jv794(param1:_hx306) : void
  374.       {
  375.          var _loc2_:_hx306 = null;
  376.          var _loc3_:_hx306 = null;
  377.          var _loc4_:Boolean = false;
  378.          if(m_world.m_lock == true)
  379.          {
  380.             return;
  381.          }
  382.          param1._wp50(m_world.m_broadPhase);
  383.          _loc2_ = m_shapeList;
  384.          _loc3_ = null;
  385.          _loc4_ = false;
  386.          while(_loc2_ != null)
  387.          {
  388.             if(_loc2_ == param1)
  389.             {
  390.                if(_loc3_)
  391.                {
  392.                   _loc3_.m_next = param1.m_next;
  393.                }
  394.                else
  395.                {
  396.                   m_shapeList = param1.m_next;
  397.                }
  398.                _loc4_ = true;
  399.                break;
  400.             }
  401.             _loc3_ = _loc2_;
  402.             _loc2_ = _loc2_.m_next;
  403.          }
  404.          param1.m_body = null;
  405.          param1.m_next = null;
  406.          --m_shapeCount;
  407.          _hx306._ai321(param1,m_world.m_blockAllocator);
  408.       }
  409.       
  410.       public function _gm184() : Number
  411.       {
  412.          return m_sweep.a;
  413.       }
  414.       
  415.       public function _gn198() : void
  416.       {
  417.          m_flags |= e_sleepFlag;
  418.          m_sleepTime = 0;
  419.          m_linearVelocity._he34();
  420.          m_angularVelocity = 0;
  421.          m_force._he34();
  422.          m_torque = 0;
  423.       }
  424.       
  425.       public function _ur192() : Boolean
  426.       {
  427.          return m_type == e_staticType;
  428.       }
  429.       
  430.       public function _vv93(param1:_sw544) : _hx306
  431.       {
  432.          var _loc2_:_hx306 = null;
  433.          if(m_world.m_lock == true)
  434.          {
  435.             return null;
  436.          }
  437.          _loc2_ = _hx306._em71(param1,m_world.m_blockAllocator);
  438.          _loc2_.m_next = m_shapeList;
  439.          m_shapeList = _loc2_;
  440.          ++m_shapeCount;
  441.          _loc2_.m_body = this;
  442.          _loc2_._br217(m_world.m_broadPhase,m_xf);
  443.          _loc2_._nw364(m_sweep.localCenter);
  444.          return _loc2_;
  445.       }
  446.       
  447.       public function _st453(param1:b2Vec2) : b2Vec2
  448.       {
  449.          return _ui293._cq423(m_xf.R,param1);
  450.       }
  451.       
  452.       public function _wv554() : *
  453.       {
  454.          return m_userData;
  455.       }
  456.       
  457.       public function _ya416(param1:*) : void
  458.       {
  459.          m_userData = param1;
  460.       }
  461.       
  462.       public function _tq424() : _hx306
  463.       {
  464.          return m_shapeList;
  465.       }
  466.       
  467.       public function _tp414() : void
  468.       {
  469.          var _loc1_:_oh327 = null;
  470.          var _loc2_:b2Vec2 = null;
  471.          m_xf.R._br741(m_sweep.a);
  472.          _loc1_ = m_xf.R;
  473.          _loc2_ = m_sweep.localCenter;
  474.          m_xf.position.x = m_sweep.c.x - (_loc1_.col1.x * _loc2_.x + _loc1_.col2.x * _loc2_.y);
  475.          m_xf.position.y = m_sweep.c.y - (_loc1_.col1.y * _loc2_.x + _loc1_.col2.y * _loc2_.y);
  476.       }
  477.       
  478.       public function _qg445(param1:Boolean) : void
  479.       {
  480.          if(param1)
  481.          {
  482.             m_flags |= e_bulletFlag;
  483.          }
  484.          else
  485.          {
  486.             m_flags &= ~e_bulletFlag;
  487.          }
  488.       }
  489.       
  490.       public function _le429() : b2Vec2
  491.       {
  492.          return m_linearVelocity;
  493.       }
  494.       
  495.       public function _cr169(param1:b2Vec2, param2:Number) : Boolean
  496.       {
  497.          var _loc3_:_hx306 = null;
  498.          var _loc4_:_oh327 = null;
  499.          var _loc5_:b2Vec2 = null;
  500.          var _loc6_:Boolean = false;
  501.          var _loc7_:Boolean = false;
  502.          if(m_world.m_lock == true)
  503.          {
  504.             return true;
  505.          }
  506.          if(_vw196())
  507.          {
  508.             return false;
  509.          }
  510.          m_xf.R._br741(param2);
  511.          m_xf.position._kh737(param1);
  512.          _loc4_ = m_xf.R;
  513.          _loc5_ = m_sweep.localCenter;
  514.          m_sweep.c.x = _loc4_.col1.x * _loc5_.x + _loc4_.col2.x * _loc5_.y;
  515.          m_sweep.c.y = _loc4_.col1.y * _loc5_.x + _loc4_.col2.y * _loc5_.y;
  516.          m_sweep.c.x += m_xf.position.x;
  517.          m_sweep.c.y += m_xf.position.y;
  518.          m_sweep.c0._kh737(m_sweep.c);
  519.          m_sweep.a0 = m_sweep.a = param2;
  520.          _loc6_ = false;
  521.          _loc3_ = m_shapeList;
  522.          while(_loc3_)
  523.          {
  524.             _loc7_ = _loc3_._ao30(m_world.m_broadPhase,m_xf,m_xf);
  525.             if(_loc7_ == false)
  526.             {
  527.                _loc6_ = true;
  528.                break;
  529.             }
  530.             _loc3_ = _loc3_.m_next;
  531.          }
  532.          if(_loc6_ == true)
  533.          {
  534.             m_flags |= e_frozenFlag;
  535.             m_linearVelocity._he34();
  536.             m_angularVelocity = 0;
  537.             _loc3_ = m_shapeList;
  538.             while(_loc3_)
  539.             {
  540.                _loc3_._wp50(m_world.m_broadPhase);
  541.                _loc3_ = _loc3_.m_next;
  542.             }
  543.             return false;
  544.          }
  545.          m_world.m_broadPhase._ol779();
  546.          return true;
  547.       }
  548.       
  549.       public function _ja306(param1:b2Vec2, param2:b2Vec2) : void
  550.       {
  551.          var _loc3_:_oh327 = null;
  552.          var _loc4_:Number = NaN;
  553.          var _loc5_:Number = NaN;
  554.          _loc3_ = m_xf.R;
  555.          _loc4_ = param1.x;
  556.          _loc5_ = param1.y;
  557.          param2.x = _loc3_.col1.x * _loc4_ + _loc3_.col2.x * _loc5_;
  558.          param2.y = _loc3_.col1.y * _loc4_ + _loc3_.col2.y * _loc5_;
  559.          param2.x += m_xf.position.x;
  560.          param2.y += m_xf.position.y;
  561.       }
  562.       
  563.       public function _tb756(param1:_fh319) : void
  564.       {
  565.          var _loc2_:_hx306 = null;
  566.          var _loc3_:_oh327 = null;
  567.          var _loc4_:b2Vec2 = null;
  568.          var _loc5_:int = 0;
  569.          if(m_world.m_lock == true)
  570.          {
  571.             return;
  572.          }
  573.          m_invMass = 0;
  574.          m_I = 0;
  575.          m_invI = 0;
  576.          m_mass = param1.mass;
  577.          if(m_mass > 0)
  578.          {
  579.             m_invMass = 1 / m_mass;
  580.          }
  581.          if((m_flags & _th791.e_fixedRotationFlag) == 0)
  582.          {
  583.             m_I = param1.I;
  584.          }
  585.          if(m_I > 0)
  586.          {
  587.             m_invI = 1 / m_I;
  588.          }
  589.          m_sweep.localCenter._kh737(param1.center);
  590.          _loc3_ = m_xf.R;
  591.          _loc4_ = m_sweep.localCenter;
  592.          m_sweep.c.x = _loc3_.col1.x * _loc4_.x + _loc3_.col2.x * _loc4_.y;
  593.          m_sweep.c.y = _loc3_.col1.y * _loc4_.x + _loc3_.col2.y * _loc4_.y;
  594.          m_sweep.c.x += m_xf.position.x;
  595.          m_sweep.c.y += m_xf.position.y;
  596.          m_sweep.c0._kh737(m_sweep.c);
  597.          _loc2_ = m_shapeList;
  598.          while(_loc2_)
  599.          {
  600.             _loc2_._nw364(m_sweep.localCenter);
  601.             _loc2_ = _loc2_.m_next;
  602.          }
  603.          _loc5_ = m_type;
  604.          if(m_invMass == 0 && m_invI == 0)
  605.          {
  606.             m_type = e_staticType;
  607.          }
  608.          else
  609.          {
  610.             m_type = e_dynamicType;
  611.          }
  612.          if(_loc5_ != m_type)
  613.          {
  614.             _loc2_ = m_shapeList;
  615.             while(_loc2_)
  616.             {
  617.                _loc2_._jt704(m_world.m_broadPhase,m_xf);
  618.                _loc2_ = _loc2_.m_next;
  619.             }
  620.          }
  621.       }
  622.       
  623.       public function _bd186(param1:_th791) : Boolean
  624.       {
  625.          var _loc2_:_gs664 = null;
  626.          _loc2_ = m_jointList;
  627.          while(_loc2_)
  628.          {
  629.             if(_loc2_.other == param1)
  630.             {
  631.                return _loc2_.joint.m_collideConnected == false;
  632.             }
  633.             _loc2_ = _loc2_.next;
  634.          }
  635.          return false;
  636.       }
  637.       
  638.       public function _nt224() : Boolean
  639.       {
  640.          var _loc1_:_ni781 = null;
  641.          var _loc2_:_oh327 = null;
  642.          var _loc3_:b2Vec2 = null;
  643.          var _loc4_:_hx306 = null;
  644.          var _loc5_:Boolean = false;
  645.          _loc1_ = s_xf1;
  646.          _loc1_.R._br741(m_sweep.a0);
  647.          _loc2_ = _loc1_.R;
  648.          _loc3_ = m_sweep.localCenter;
  649.          _loc1_.position.x = m_sweep.c0.x - (_loc2_.col1.x * _loc3_.x + _loc2_.col2.x * _loc3_.y);
  650.          _loc1_.position.y = m_sweep.c0.y - (_loc2_.col1.y * _loc3_.x + _loc2_.col2.y * _loc3_.y);
  651.          _loc5_ = true;
  652.          _loc4_ = m_shapeList;
  653.          while(_loc4_)
  654.          {
  655.             _loc5_ = _loc4_._ao30(m_world.m_broadPhase,_loc1_,m_xf);
  656.             if(_loc5_ == false)
  657.             {
  658.                break;
  659.             }
  660.             _loc4_ = _loc4_.m_next;
  661.          }
  662.          if(_loc5_ == false)
  663.          {
  664.             m_flags |= e_frozenFlag;
  665.             m_linearVelocity._he34();
  666.             m_angularVelocity = 0;
  667.             _loc4_ = m_shapeList;
  668.             while(_loc4_)
  669.             {
  670.                _loc4_._wp50(m_world.m_broadPhase);
  671.                _loc4_ = _loc4_.m_next;
  672.             }
  673.             return false;
  674.          }
  675.          return true;
  676.       }
  677.       
  678.       public function _dx743(param1:b2Vec2, param2:b2Vec2) : void
  679.       {
  680.          if(_bk718())
  681.          {
  682.             _uo631();
  683.          }
  684.          m_linearVelocity.x += m_invMass * param1.x;
  685.          m_linearVelocity.y += m_invMass * param1.y;
  686.          m_angularVelocity += m_invI * ((param2.x - m_sweep.c.x) * param1.y - (param2.y - m_sweep.c.y) * param1.x);
  687.       }
  688.       
  689.       public function _dd348(param1:Number) : void
  690.       {
  691.          m_sweep._dd348(param1);
  692.          m_sweep.c._kh737(m_sweep.c0);
  693.          m_sweep.a = m_sweep.a0;
  694.          _tp414();
  695.       }
  696.       
  697.       public function _xy71(param1:b2Vec2) : void
  698.       {
  699.          m_linearVelocity._kh737(param1);
  700.       }
  701.       
  702.       public function _nm713(param1:b2Vec2) : b2Vec2
  703.       {
  704.          return new b2Vec2(m_linearVelocity.x - m_angularVelocity * (param1.y - m_sweep.c.y),m_linearVelocity.y + m_angularVelocity * (param1.x - m_sweep.c.x));
  705.       }
  706.       
  707.       public function _fj808() : Boolean
  708.       {
  709.          return (m_flags & e_bulletFlag) == e_bulletFlag;
  710.       }
  711.       
  712.       public function _pj447(param1:b2Vec2) : b2Vec2
  713.       {
  714.          var _loc2_:_oh327 = null;
  715.          var _loc3_:b2Vec2 = null;
  716.          _loc2_ = m_xf.R;
  717.          _loc3_ = new b2Vec2(_loc2_.col1.x * param1.x + _loc2_.col2.x * param1.y,_loc2_.col1.y * param1.x + _loc2_.col2.y * param1.y);
  718.          _loc3_.x += m_xf.position.x;
  719.          _loc3_.y += m_xf.position.y;
  720.          return _loc3_;
  721.       }
  722.    }
  723. }
  724.  
  725.